Instanciating a Type at Runtime – C# Benchmarks

Assuming you are familiar with C#;
If I give you a Type and tell you to create an object with it, you would automatically think of Activator.CreateInstance right?
What if I tell you that instanciating a Type using Expression Trees is much faster?

The code for the benchmarks is in this repository.

Background

I am currently in an internship and the project I’m working on needs to be as extensible as possible.
Meaning that users/developers should have the possiblity to add new functionalities (or at least a variant of a functionality) easily.

For instance, I have a Manager class and a couple of default classes that inherit implement, each of them does something specific.
Now the idea is to make it possible for people to plug-in their SomethingManager class.

I ended up with a list of Type that inherit from Manager. Now all I have to do is instanciate and execute these types when I need them. Like most C# programmers, I immediately thought of Activator.CreateInstance!

However, there must be a faster way for instanciating a type right?

Instaciating a type - some of the ways

Let’s imagine that our base class is TestClass.

Activator

[Benchmark]
public TestClass Activator()
{
    return (TestClass)System.Activator.CreateInstance(_type);
}

ConstructorInfo (Reflection)

// This line should only be ran once
var _constructor = _type.GetConstructor(Type.EmptyTypes);

[Benchmark]
public TestClass Constructor()
{
    return (TestClass)_constructor.Invoke(null);
}

Expression Trees

// This line should only be ran once
var _delegate = Expression.Lambda(Expression.New(_type)).Compile();

[Benchmark]
public TestClass Delegate()
{
    return (TestClass)_delegate.DynamicInvoke();
}

Func<object> (Expression Trees)

// This line should only be ran once
var _func = Expression.Lambda<Func<object>>(Expression.New(_type)).Compile();

[Benchmark]
public TestClass Func()
{
    return (TestClass)_func();
}

Func<TestClass> (Expression Trees)

// This line should only be ran once
var _typedFunc = Expression.Lambda<Func<TestClass>>(Expression.New(_type)).Compile();

[Benchmark]
public TestClass TypedFunc()
{
    return _typedFunc();
}

Results

I added the new TestClass() benchmark as a baseline.
As you can see, Expression Trees compiled Func<object> or Func<TestClass> are so close to being as fast as the baseline.

On the other hand, Expression Trees compiled to a plain Delegate and called using DynamicInvoke() are extremely slow.
This is due to the fact that a Delegate is dynamically invoked, .net has to use Reflection to figure out the Type and other informations, and this happens everytime.

For more informations, check this Stackoverflow question.

Raw results

To sum up, instanciating a type at runtime can be done in multiple ways.
The fasted way (in these benchmarks) is using Expression Trees to generate a typed Func<X> and invoke it when needed.

For the future, I should also benchmark running IL Code directly.